This experience is not available in the language you selected.
Proceed
Build Your ThingWorx Solution for Manufacturing
Download Success PathIMPORTANT: When saving the file, in the Print window please do the following: Destination or Printer: select Save as PDF More Settings: In the Options, be sure the boxes Headers and footers and Background graphics are selected.
Build Your ThingWorx Solution for Manufacturing
Everything you need to implement Industrial IoT in your manufacturing plants
This is a PDF version of Build Your ThingWorx Solution for Manufacturing . downloaded on Date : 4/10/2025 4:54:09 PM
and may be out of date. For full latest version click here.
Overview: Build Your ThingWorx Solution for Manufacturing
Use this guide as you plan, design, develop, and deploy a ThingWorx solution for manufacturing. Follow step-by-step instructions and get resources to help you get the most out of the product. For example, the guide will help you establish business goals and develop long-term ThingWorx strategy.
The information is useful for:
Project Managers
Project Stakeholders
System Administrators
Technical Staff
Developers
UI/UX Designers
What is a Success Path?
A Success Path is an online guide to help you implement a specific PTC product at your organization. Each path provides step-by-step instructions and includes training and resources along the way. Use a Success Path to help your organization get the most out of a product and achieve your business goals.
Selecting the right use case is critical to your Industrial IoT success. Start by exploring the factors driving the organization. Then identify the problems and opportunities that could bring the most value. Finally, design your use case to achieve that value.
To get the support your project needs, you must demonstrate how Industrial IoT supports your organization’s strategic goals. Early in the project, identify which factors create the most value for shareholders. How does your organization plan to remain successful and profitable in coming years? Consult executives about these high-level business drivers. Important business drivers may include revenue growth, asset utilization, or margin optimization.
02. Identify business challenges
Talk to business leaders about which challenges are preventing your organization from achieving its high-level business drivers. Ask departments about their biggest obstacles. Additionally, start learning how these leaders calibrate their goals and measure success.
For example, if your organization’s top business driver is asset utilization, your business challenges may include machine downtime or changeover time.
Do your best to avoid problem-solving and brainstorming. For now, you’re concerned with the challenge, not with potential solutions.
03. Map business challenges to use cases
Estimate the effort, value, and applicability of solving the business challenges you’ve identified. Work with subject matter experts to make realistic projections. If possible, gather data about operations, quality, financials, and other factors that predict potential value. The numbers may surprise you: often, organizations have an Industrial IoT use case in mind, but later discover that solving that particular business challenge brings minimal value to the organization.
04. Prioritize use cases
Compile your business challenges and data, then create a matrix. Rank each business challenge’s effort, value, applicability, and scalability.
Business challenge
Effort to solve
Value
Applicability
Scalability
Improve equipment uptime
Moderate: Workers struggle to implement new processes, and may resist change
Moderate: 2 percent increase in uptime at Plant A delivers a 5 percent increase in output
Low: Plant B lacks internet connectivity and technology infrastructure
Unknown
Reduce scrap rate
Moderate: Workers struggle to implement new processes, and may resist change
High: 2 percent decrease in scrap will reduce costs by $800k as copper prices rise
High: Equipment includes proper sensors to connect data
Moderate: Challenge is relevant to 80 percent of plants in North America
Ideally, your matrix will reveal challenges that are possible to address, present high potential value, and have infrastructure already in place. Also, remember to think about scalability.
05. Finalize your use case(s)
Work with stakeholders to select the most valuable use case(s) for Industrial IoT. Don’t be afraid to tackle big challenges with big returns: if your use case supports your organization’s key drivers, you’re more likely to get the leadership support for your project needs.
Document your chosen use case and confirm it with project stakeholders.
06. Explore the software you need
To implement your use case, you will need a suite of technology solutions. For example, ThingWorx manufacturing applications and/or ThingWorx analytics, augmented reality technology, or other solutions may be required. To learn which software is best for your use case, contact your PTC salesperson.
07. Identify initial project scope
Ensure all the appropriate stakeholders agree to the scope of your Industrial IoT project. For many organizations, the scope has substantial, rapid impact. Over time, the project leaders will learn and iterate—extending the solution to solve bigger challenges. Follow the plan and ensure the scope is appropriate for your use case.
Consider questions like:
Which plant/location will be the first to deploy the solution?
How many machines and connectors will be affected?
Are there processes that must evolve?
How many workers will require training?
What is the timeline?
For now, focus on the initial implementation—assuming the solution will scale rapidly in the future.
Document Your Measurement Strategy
One of the most important steps to implement Industrial IoT is to measure the business impact. Demonstrating how the initiative is solving real business problems will help you get buy-in across the organization. After you finalize your use case, set measurable goals and metrics.
Your goals and metrics will vary, depending on your organization’s use case and initial project scope. Start by identifying the business challenge and desired outcome that ThingWorx was selected to solve. Confirm the scope of what you’re measuring: do your goals apply at the line(s) level, or the entire factory plant? This process typically takes place when you select your use case.
Next, specify your goal for addressing the business challenge: how will ThingWorx alleviate the problem? Your goals should be measurable.
Common goals include:
Reduce scrap or rework by 15%
Increase operational efficiency by 5%
Increase on-time ship rate to 90%
After identifying your goals, determine which metrics or key performance indicators (KPIs) you will use to measure success. For example, if your goal is to increase operational efficiency, your KPIs may include the number of operators in the plant and total equipment downtime. If you don’t have access to the data you need, reach out to the plant manager or leader.
02. Finalize goals and metrics
Collaborate with stakeholders across your organization to finalize your goals and metrics. Ensure the project sponsor, key leaders, and other team members agree on the goals. And verify whether you can measure the identified KPIs.
Establish a thorough understanding of what the goals are, how the metrics will be tracked, and who is responsible for doing so.
03. Establish baseline metrics
If possible, you should document your organization’s “as-is” state. Establishing baseline metrics will help you prove that ThingWorx had the intended effect on your organization. For example, if your goal is to increase operational efficiency at a specific plant, you should record the current-state metrics for that plant, before you deploy ThingWorx.
In many cases, it isn’t possible to capture accurate baseline metrics. Your organization may not be capable of measuring the right things—but will have deeper insight after ThingWorx is in place. Or there may be other initiatives happening in parallel that will affect those metrics later. If the exact metric is not available or accurate, a high-level approximation is acceptable.
04. Document your measurement plan
After you identify your goals and metrics, it’s important to document a detailed measurement plan.
The measurement plan should outline:
Short-term goals
Long-term goals
Key performance indicators and metrics
Roles and responsibilities: who will track and report performance, and who needs to be informed
Key milestones
Baseline metrics/current state
Other items, as needed
Share the measurement plan with stakeholders and refer back to it throughout the project to ensure you’re on track.
Assess Existing Infrastructure and Processes
Identify areas that must change to accommodate Industrial IoT. By documenting your current infrastructure and processes, you can plan where you’re headed.
Document the architecture that supports your organization’s manufacturing operations, including hardware, software, and network materials. While you’re documenting what exists, start inquiring about what’s not working today and what you’d like to change in the future to support your use case.
02. Document existing processes
Make sure you have a high-level understanding of any processes that relate to your selected use case. Take note of the people who are involved, as well as the tasks. While you will be most focused on processes that revolve around manufacturing, keep in mind that these changes may have implications beyond the factory floor. If your IIoT implementation will impact other departments—such as human resources, engineering, or finance—document that too.
03. Document existing connectivity
It's also helpful to document any existing systems or data connections you have in place today that relate to your chosen IIoT use case. Include how you currently connect to those systems and any improvements you’d like to make in the future.
Estimate Resources Needed
To achieve your Industrial IoT use case, you will need an experienced team. Explore the skill sets and experience your project team needs. Determine whether your organization employs the right talent, internally. Then consider engaging an outside resource to bridge any gaps, if necessary.
You will need a variety of contributors to implement Industrial IoT. The number of team members will vary, depending on the scope of your use case. Having experience implementing ThingWorx will be a major advantage. Systems integrators can often fill gaps in skill sets and experience.
Although their professional titles may differ, typically you need the following team members.
Solutions Architect: As the lead technical resource for your Industrial IoT application, the IIoT Solutions Architect will design the overall solution. They will also coordinate efforts across the infrastructure and development team.
Skill sets needed:
A blend of technical and application architecture expertise
Strong communication and leadership skills
Strong background creating solutions on the ThingWorx Platform with heavy emphasis on creating ThingModels
Experience with Industrial connectivity solutions, preferably Kepware
Experience with systems integrations design, including the use of REST APIs
Proven track record in architecting performant and scalable solutions
Software Engineer: The software engineer(s) will develop applications under the direction of the solutions architect. IIoT solutions development work will typically be done using Agile software development processes. Depending on the scope of your project, you may need more than one engineer.
Skill sets needed:
Familiarity with full-stack development
Proficiency in common development languages, specifically JavaScript, Java, and Python
Experience with the creation and use of Java Extensions
Experience using Eclipse, a Java IDE typically used for ThingWorx development
Experience in the development of systems integrations, specifically using REST APIs
IT Administrator: Your IT partner maintains your organization’s IT network, servers, and security systems. They will also play a role in building and operating your IIoT application.
Skill sets needed:
Experience working with scalable, performant systems with a specific focus on the added challenge of high-scale connectivity
Knowledge of maintaining redundancy and high systems availability to avoid unplanned outages
Data Scientist: The data scientist will work to extract meaning from and interpret data. They will use tools and processes to fetch the data and analyze it to understand how the organization is performing.
Skill sets needed:
Ability to extract, analyze, normalize, and organize data
Experience with Machine Learning Algorithms and training Machine Learning Models
Deep knowledge of descriptive, diagnostic, predictive, and prescriptive data analytics
Embedded Developer (Edge): An embedded developer is not always required. This developer builds agents and other software that run on the devices processing your IIoT data.
Skill sets needed:
Experience developing agents with SDKs for different programming languages including C and Java
Strong understanding of network communications protocols (i.e. J1939, Modbus), policies, and best practices
UX/UI Designer: Although not absolutely critical for the project, a UX/UI Designer will design the look and feel of the application interface and make it easier to use.
Skill sets needed:
Proficient in CSS, Adobe Photoshop, Adobe Illustrator, and/or Sketch
Familiar with user-centered design principles
Experience designing mobile, tablet, and desktop applications
Business Process Consultant: Although not absolutely critical for the project, a business process consultant will help determine how to best intersect new technology with your business processes to improve efficiency.
Skill sets needed:
Thorough understanding of your organization and specific business processes as they exist today
Experience with process modeling and the creation of future processes
Experience partnering with stakeholders to gather business requirements
Explore whether your organization employs people who have these skill sets. If so, ask the employees whether they can make themselves available to contribute to the project. Get their manager’s approval, if necessary. Most of the work can be done remotely, but it’s important that most team members can be on-site to gather requirements and for the “go-live” stage.
03. Determine outside resources needed
Typically, organizations will hire contractors or consultants to bridge skills gaps and achieve their use case. If internal employees are non-existent or unavailable, engage an outside resource. Verify the individuals you hire have the appropriate skills and experience to meet your project goals.
If you have purchased a Success Plan from PTC, you have access to IIoT experts who will support and guide you. Customer Success Management can help you plan, implement, and measure your IIoT initiative. Your PTC Customer Success Manager will ensure you have the right mix of resources on your team to be successful. They’ll help to ensure each contributor has extensive experience with the ThingWorx platform and is well suited to achieving your use case. If you don’t have a Success Plan, contact your sales representative.
Plan Stakeholder Involvement
Determine who should be involved in your Industrial IoT initiative. Then specify how you will communicate with stakeholders to ensure they remain engaged.
Stakeholder support will be a key asset throughout your Industrial IoT project. Cultivate buy-in at various levels of your organization, from high-level business leaders to frontline workers. Your most important stakeholder will be at the executive level: identify a well-respected, well-connected executive champion who will advocate for your initiative on an ongoing basis.
In addition to the people who champion Industrial IoT solutions, you’ll also need end users to test them in the real world. Identify a manageable group of workers who will test and provide feedback on early-stage applications. These workers should represent your ideal end users. They will help you identify urgent fixes and opportunities for improvement before you implement ThingWorx on a larger scale.
Possible stakeholders may include:
Corporate Executives
IT Leaders
Plant Managers
Machine Operators
End Users
02. Create a communication plan
Determine how, when, and to whom you will communicate throughout your Industrial IoT project. Your stakeholders will have different needs, depending on their role.
As you plan how to communicate with your stakeholders, answer these questions:
How frequently will you share information? Some stakeholders will provide daily feedback and direction on the project, while others may get involved on a passive, less-frequent basis.
What’s the best channel for that information? Emails, calls, or meetings may work for some stakeholders and not others.
What information is most important to which stakeholders? Be careful to avoid communication overload.
What do you need from your stakeholders at various points along the timeline? Establishing key milestones or successes in these communications will help to maintain momentum and excitement.
Keep in mind that your stakeholders’ involvement and communication needs may change over the course of the project. Modify your approach as you go, if needed.
03. Plan feedback mechanism
While it’s important to communicate, it’s also imperative to listen. If stakeholder communication is only coming from one direction, you risk overlooking valuable feedback or missing opportunities to address concerns. Establish channels for soliciting and responding to feedback across your organization—and ensure stakeholders know how to get answers.
04. Kick off your IIoT initiative
Hold a meeting with all of your stakeholders to kick off the project and establish a shared understanding of your goals. If appropriate, review the use case, measurement strategy, roles and responsibilities, and other aspects of the project plan. Provide plenty of time to answer stakeholders’ questions. If you plan to have ongoing meetings, agree on the cadence and specify future meeting dates.
Train Your Team
PTC recommends scheduling training for various members of your Industrial IoT project team. Ideally this training takes place early in the project. If you’re not sure which option is right for your organization, contact your PTC sales representative to learn more.
Determine training needs based on the roles on your team and your chosen use case(s). We have many options to help you start building applications with ThingWorx. For example, we have courses to learn to develop in ThingWorx, how to manage platform security, and a course for DevOps practices, among many others.
Most courses are available through PTC University Training Central (requires a PTC account). A PTC training advisor can help you choose which courses are the most important for your team.
Training delivery methods and cost
Depending on the course, training is available online or in person. We can bring experts to your location, you could join a class at a central location, or participate online.
Costs depend on the course and delivery method. The LEARN Online Subscription gives you access to the entire catalog of ThingWorx courses that you can take online with a live instructor. To find out your options, talk to a training advisor.
To buy or sign up for PTC training courses, talk with a Training Advisor. You can find course listings, descriptions, and schedules at PTC University Training Central (requires login).
The members of your project team should complete training as soon as possible. This enables each person to put their knowledge to practice as you work towards shared goals.
Determine How to Maintain and Scale Your Applications
It’s important for your organization to plan how and where it will deploy and maintain future ThingWorx applications.
Plan when and how the application(s) you’re building should be deployed to additional locations beyond your initial launch. For each additional site, include:
A high-level production schedule
The resources required
Any training activities needed
02. Determine how to manage your ThingWorx applications
PTC recommends that application configuration be consistent across sites. The configuration should be maintained through a dedicated, central application management team after deployment. This team is responsible for:
Assessing and prioritizing any changes requested to the existing application
Creating and maintaining the application roadmap
Determining the cadence in which new versions and iterations will be deployed
Scheduling new version implementations across each site, including training for end users and the application support team
Ensuring the application is meeting the needs of the organization
As your organization launches additional applications to support multiple use cases, PTC recommends staffing:
A subject matter expert for each use case
An architect to oversee the entire Industrial IoT initiative and ensure the applications are working together
03. Determine how to manage the system
Assign a team to be responsible for managing the health of the system that supports your IIoT application(s). This systems management team—typically comprised of IT professionals—is responsible for:
Ensuring the system is operating as it should
Responding to outages
Monitoring the existing system performance and quality
Implementing system upgrades
04. Plan handoff details
After your IIoT project is deployed, the project team will transfer ownership to the appropriate application and system management teams. The handoff may take place immediately after go-live deployment, or weeks afterward. Choose the milestone or date when the handoff will take place.
Develop Your Application Support Strategy
Plan and communicate how users will get help using ThingWorx applications. Internally, specify which teams are responsible for various aspects of the application and how they will triage issues. Your application support model should be based on your responsiveness and uptime requirements.
Develop processes for providing post-deployment technical support to ThingWorx application users. Ideally, all operators, managers, and other users will know who to contact and how to get help resolving technical issues.
As you design your support model, there are several best practices to follow:
Establish support responsibility early in the project. In the early stages of your Industrial IoT project, determine who will support the applications in the long term. Assigning these responsibilities early ensures the right people gain the knowledge they need to troubleshoot and maintain the application.
Create thorough documentation. Thorough documentation is crucial for long-term supportability of the solution. The support organization will need specific details about how the application is designed and implemented in order to resolve issues, fix bugs, and perform system maintenance in a timely manner. Whether you’re using internal employees or an external resource to build the application(s), you must document the delivered solution for ease of knowledge transfer and future reference.
Plan your handoff. Decide when and how your Industrial IoT project team will transfer ownership to your designated support organization. Ensure your support organization receives training on the implemented solution before the project wraps up. All support teams should also receive basic ThingWorx training to ensure they have a sound understanding of the core ThingWorx Platform.
02. Determine support strategy
Create a plan for how your organization will maintain and address potential issues that may arise in the day-to-day operations. Here are a few points to keep in mind:
Availability: Your organization must decide whether your ThingWorx apps are critical to the manufacturing process and define your support model accordingly. If it’s a 24-hour-per-day, 7-days-per-week operation, your support must be available on a 24/7 basis. If your operations do not run 24/7, you can adjust availability accordingly. The key is to ensure the responsiveness of the support organization is aligned to the criticality of the systems.
Roles and responsibilities: Who, specifically, should deliver support? The responsibilities may span different areas. For example, one team may be responsible for machine connectivity and another oversees application maintenance. Your IT team likely has a “help desk” that will be the first point of contact for support. Determine how the teams will triage issues among the various experts at different tiers.
Escalation: How will technical support escalate issues that are outside their domain of expertise? How will they handle complex issues that require additional expertise? In a tiered support model, your team will evaluate issues to determine the root cause and triage accordingly. PTC support may be contacted for any product-related issues or questions.
To access PTC technical support, you will log a case with PTC eSupport. Once received, a member of the technical support team will assist you.
Finalize and document the application support process. Outline who is the first point of contact, and how to escalate potential issues. Verify everyone in the support organization agrees to the process and is prepared to execute it. Plan checkpoints throughout the year to ensure the process is working and improve it if necessary.
Ensure your end users know how to get help with their ThingWorx application, should issues arise.
04. Plan handoff details
After you deploy your Industrial IoT application, the project team will transfer ownership of the live solution to your designated support organization. The handoff may take place immediately after go-live deployment, or weeks afterward. Choose the milestone or date when the handoff will take place. Finally, ensure all parties are comfortable supporting the solution going forward.
Manage Organizational Change and Compliance
Ensure your organization is ready, willing, and able to function in a new business environment. An organizational change management plan will speed up your Industrial IoT implementation and facilitate success.
For the frontline workers, managers, and other employees who will be using your Industrial IoT application—the world is changing. Your workforce will be adopting a new mindset, developing new skills, and learning new technology and processes. And while necessary, change can be difficult.
To help employees embrace change, plan to:
Communicate consistently
Listen openly to concerns and questions
Encourage participation
Share the benefits that Industrial IoT will bring to the employees and organization as a whole
Obtain active and visible executive sponsorship
Dedicate resources to planning and enacting change management
Create a plan to help your organization adapt to change.
02. Determine your compliance and regulations plan
Organizations in some industry verticals must follow strict compliance regulations for managing data. For these use cases, there may be security and safety standards to consider.
Plan how Industrial IoT will affect your organization’s compliance processes. Identify who you should contact regarding compliance and involve them in your project planning as soon as possible.
03. Document your change management plan
A change management plan specifies how an organization will transform from where it is today to where it aims to be in the future. A successful change management process should be continuous: start with defining a vision and continue to measure progress after the change takes place.
Your change management process should:
Define a compelling vision and clear objectives
Ensure strong leadership and effective sponsorship
Build and maintain ownership and accountability
Align processes, organization, and culture
Involve employees
Provide adequate enablement and support
Ensure stakeholder-specific communication
Measure and monitor benefits realization continuously
Document your change management plan and share it accordingly.
Draft Application Designs
Begin exploring what your Industrial IoT application should do and how users will interact with it. Then sketch a first draft of your application. Your goal is to ensure your application is useful, usable, and appealing.
Application requirements specify what your Industrial IoT application needs to do.
To maximize the usefulness of your application, explore what your end users (employees working in the plant) need from it. We recommend a software engineer, systems integrator, or product owner collaborate with a UX designer to conduct basic research. If you don’t have a UX designer, a developer typically fills this role.
Your research should answer questions like:
Who will be using the application?
What are their goals? What tasks must they accomplish?
What are their pain points and challenges in their daily jobs?
Who do they work with to accomplish important tasks?
How does their physical environment affect how they do their jobs?
What hardware will they be using for the app (desktop, mobile, tablet)?
If possible, visit the factory or environment in person to learn about your users. Observe them in their work setting and interview them about their needs. Aim to study a representative sample of users.
Your research should reveal a long list of requirements possibilities for your application. Prioritize which items are most relevant to solving the business problem specified in your use case.
02. Gather UX requirements
User Experience (UX) requirements specify how the user will interact with your IIoT application (interaction design).
Among other elements, the UX requirements will outline how the app displays information and how the user interface will function.
To gather your UX requirements, review your user research and imagine how those users will interact with your application. For example, if your end user is responsible for monitoring battery life on a set of machines, your UX requirements would answer questions like:
What’s the best way to display battery information? A progress bar, a percentage, or another visual representation may be the right choice.
Does the user need to be alerted when battery levels are too low?
After checking battery life, what will the user need to know or do next?
Does the plant manager need different information than the controls engineer?
There are a variety of ways to document UX requirements. Be sure to focus on who will be using the application, what they’re using it for, and the features and functionality that will meet their needs.
03. Create initial wireframes
Wireframes are low-fidelity, early stage designs. They provide direction for the developers building the application and convey how users will interact with it. Wireframes often contain a grid of empty boxes that represent elements on a screen. They’re typically designed using tools like Balsamiq or Axure, but they can also be hand-drawn.
Wireframes typically include:
Elements on the screen: These empty boxes represent the navigation, titles and labels, blocks of text, graphs, images, buttons, and more.
Priority and relationships: By arranging and connecting various elements, wireframes reveal which items are most important.
Interaction: For interactive elements, wireframes note how the element responds when the user clicks or taps on it.
Flow: If there are multiple screens, the flow outlines which leads to the next. If the application delivers alerts, wireframes will indicate this.
Preliminary copy: The words in the design will help convey what each element is and does. For example, a heading may say “battery life,” or a button may read “view all machines.” These words can change later in the design process.
Wireframes do not usually include colors, images, or other styling. Those aspects of the design will be decided later.
Depending on the hardware you’re using to run your Industrial IoT app—desktop computers, tablets, or other displays—you will have limited screen space. Instead of filling the screen with widgets, prioritize what’s most important and leave blank space. Review your requirements and user research to decide what’s most important. The fewer elements the user sees, the easier your application will be to learn and use.
Remember that your wireframes will change and evolve. Later in the project, you will review, test, and improve upon these early stage designs.
04. Design user groups
Now that you know how users will interact with the application, outline your user groups. User groups restrict what workers can see and do in the application. For example, a machine operator may need to view X, Y, and Z screens, but will never make changes to them. An administrator, on the other hand, should have full access to the application. Thus, these two types of users would belong to different user groups.
Review your list of potential users. Then determine which types of users should have permission to access which information within ThingWorx.
Keep in mind:
Balance permissions carefully. If you grant users too many permissions, they could see confidential data or mistakenly delete pieces of the application. If you grant users too few permissions, they may be unable to access an important screen.
In ThingWorx Composer, you will create groupings at three levels:
Organization
Organizational unit
User group
There are three forms of permissions you can adjust:
Visibility permissions dictate what Mashups and/or dashboards a user can see. Visibility permissions are assigned at an organization/organizational unit level.
Run-time permissions dictate what services a user can execute and properties they can access. Run-time permissions are assigned at the user group level.
Design-time permissions dictate what a user can modify/access in Composer. Design-time permissions are assigned at the user group level.
Adapt as needed. You will likely need to make changes to your user groups and permissions over time.
ThingWorx offers user groups for administrators, developers, and users: Depending on your needs, these user groups may be sufficient to start with. Later in the process, you will set up the appropriate groups and invite users to ThingWorx.
Document Your Integration and Connectivity Strategy
The real power of ThingWorx comes from its ability to pull data from disparate sources into a single application to gain new insights and drive new actions. Plan how you will integrate with the systems and connect to the machines necessary to achieve your use case.
The first step: collect a list of requirements. These items are the must-haves in your integration and connectivity strategy and should be specific to helping you support your identified Industrial IoT use case. Having an initial wireframe design of your application will help you understand and identify the information you’ll need to access.
Your requirements should include:
The data you need: Note the specific pieces of data or metrics you need to build the application for your use case. Also note what format the data needs to be in.
How often that data needs to be updated: Does the data being used in your application change frequently and need to be updated in order to be useful? Keep in mind that the higher the frequency of updates, the more transactions your infrastructure will need to support.
Where that data lives: Whether in a third-party system, an in-house solution, a .csv file, a machine, or something else—you’ll need to identify where this information is currently housed.
Whether the connection needs to be unidirectional or bidirectional: Is it enough for the data to simply be passed to ThingWorx to be used in the application, or does ThingWorx need to be able to pass information back?
Why you need the data: Continually ask yourself what the data is being used for to decide whether it’s truly necessary. Avoid gathering data that isn’t crucial for your IIoT use case.
ThingWorx customers commonly connect to a variety of tools, including:
Product Lifecycle Management (PLM)
Enterprise Resource Planning (ERP)
Manufacturing Execution System (MES)
Data historian
Enterprise Asset Management (EAM)
Customer Relationship Management (CRM)
Programmable Logic Controllers (PLCs)
Custom SQL databases
Enterprise data lake
And more
02. Determine integration connectors
Now that you have a clear picture of what data you’ll need to access for your application, you need to determine how to create the connections to that data. ThingWorx collects data in two ways:
Integrations: You integrate to systems that house data.
Connectivity: You connect to machines or physical assets.
When it comes to integration, ThingWorx has a number of integration connectors built in and ready to use. But depending on what kind of integrations are required, some custom-built options might be needed as well.
To decide on the best approach for your organization and selected use case, we recommend having a detailed conversation with your solution architect (with strong ThingWorx knowledge), controls engineer, IT and OT experts, and any others who have the deep understanding of the specific data and systems to which you’re trying to connect.
Your use case may require you to connect to machines or physical assets. In the IoT industry, the devices and things that connect to the cloud are often called the edge: The things connect from outside the ThingWorx platform and send data into the platform. There are a variety of edge devices, like programmable logic controllers (PLCs), Raspberry Pis, routers, and more.
If you must connect to edge devices, determine your requirements. The data requirements you established are a great place to start. In addition, your edge device requirements should address:
How to communicate with the device:
What kind of data transfer/application protocol does the device use?
Does it have a physical user interface?
Will you need to convert from analog to digital?
Is it wireless or hardwired to a network?
How to retrieve the data:
Where does the data live on the device?
How will the data travel from the edge device to ThingWorx?
Are there any security barriers you need to address?
Depending on the device, there are numerous ways to connect. For manufacturing use cases, we recommend you use Kepware to communicate with edge devices. Choose the technology that will meet your requirements.
A systems integrator will help answer these questions. If possible, determine who programmed the device you’re connecting to. It may be a control engineer or programmer within your organization, a third-party vendor, or machine builder. This person can provide invaluable expertise as you connect to edge devices.
The power of ThingWorx comes from its ability to aggregate disparate data into a single place. You must structure that data in a way that your ThingWorx applications can use it. Your data model architecture will be a digital representation of everything that provides data in ThingWorx and the relationships between those things.
Your ThingWorx data model is comprised of these entities:
Things are digital representations of all of your assets, devices, systems, people, or processes that provide data.
Thing Templates store core functionality (properties, services, events, and subscriptions). All Things need to be associated with a Thing Template, inheriting its identified functionality.
Thing Shapes also store functionality but can be applied to single or multiple Thing Templates or Things. We recommend using Thing Shapes when there are properties, services, events, or subscriptions that span across multiple Thing Templates or Things across several Thing Templates.
While ThingWorx allows your data model to evolve over time, it’s important to spend time determining how to structure your data early in the project. The best place to start: compile a list of Things required for your use case. From there, start to understand the relationships between those Things.
This is just a brief introduction to the ThingWorx Data Model. Use the recommended resources below to learn more and prepare to design your data model. We recommend working with a system integrator, programmer, or developer with object-oriented programming experience to design your data model.
05. Document your integration and connectivity strategy
Now that you know which data sources you need to connect to and how you plan to connect to them, it’s important to compile this information in a documented integration and connectivity strategy. This document will help inform other decisions that need to be made, including any changes to your infrastructure and detailing a timeline for your ThingWorx project.
Your documented integration strategy should include:
Requirement of each integration connector that will be used
A list of all transactions that need to occur, including the frequency
All of the data fields you will be collecting
Decisions on what will act as the main system(s) of record (the source of truth for your data)
Any security considerations that need to be addressed
Plan Your Infrastructure
Ensure you have the proper infrastructure to support your Industrial IoT use case.
Determining what kind of hardware end users will need to interact with your ThingWorx applications will ensure you design the proper infrastructure to support them.
When choosing hardware for end users, you should consider:
Whether end users will need to move around with a device or simply view the application from a stationary terminal
Environmental factors such as temperature or exposure to water, dust, or other elements
How end users will need to interact with the application(s). Here are some examples to consider:
If your end user will be wearing gloves, a touchscreen device may not be the best option
Does the application require your end users to need one or both hands free?
Are your users going to be wearing any safety gear, such as helmets or eye/ear protection that could hinder their ability to see or hear?
02. Define and document an architecture plan
Your architecture plan should specify what systems you need, how they should be configured, and what size those systems need to be to run your IIoT applications.
It’s important to know if your organization plans to expand this use case into other factories, create more applications to support additional use cases, or connect additional data sources in the future. Design your infrastructure to meet those needs from the beginning. Designing an architecture that can support these things will take more time initially but make it easier to expand capabilities later.
When defining your architecture plan, you should consider:
Deployment: Whether you will be deploying ThingWorx on-premises, in a PTC-hosted cloud, or your own cloud
Availability: If ThingWorx and any applications you deploy will need to be available at all times or if some down time is acceptable
Environments: How many environments you’ll need and the expected number of users each environment will need to support. We recommend having three environments:
Development: Also referred to as “dev,” this is the space your developers can use to create new applications, features, or work on patches.
Production: This environment will host the live, tested applications your end users will interact with. It’s often referred to as “prod.”
Quality Assurance/Test: This environment lives between dev and prod. Here, you’ll validate and test new versions, patches, and configurations. Your QA/test environment should be as close of an exact replica to your prod environment as possible.
Networking to support end users: Ensure you have the proper network to support the end users of your ThingWorx applications. The research you did to determine which devices your end users will need should help guide your network design.
Usage: To understand what hardware—and how much processing and memory—you need for ThingWorx, you’ll need to consider:
How many end users will be accessing data during peak usage
The number of data points that will be called during peak usage
The number of services called during peak usage
The total number of Things (devices, sensors, connections, modules, etc.) that will be managed by ThingWorx
The frequency at which data is sent from each Thing to ThingWorx
Document your final decisions and share them across the project team for execution. This document should outline the components you need, how they relate to each other, and where they need to be located.
Once you’ve completed your architecture plan, compare it to what exists today. Take note of what you’ll need to purchase and what things need to change in order to get you there.
04. Begin sourcing hardware
If your architecture plan requires additional hardware, it’s important to start sourcing that hardware right away—especially if the procurement process at your organization requires multiple approvals.
Finalize Technical Design
Decide the details of your Industrial IoT application design. As you create a technical design, get input from the developers and architects who will build it.
Earlier in the IIoT project, you created wireframes outlining your application design. Now you will create a complete design that provides more detailed information on how it looks and functions. Keep in mind that the styling and customization options are limited within ThingWorx.
A technical design typically includes:
User interaction details: What happens when a user hovers over/taps a button, for example?
Near-final copy: What words will you use for buttons, labels, and navigation elements?
Visual design: What color palette, fonts, and other styles will the design employ? If your organization has brand/design standards, ensure the design is consistent with those requirements. The application should look similar to other applications your organization uses.
Data needs: What data will flow into your design? Note where specific datasets are needed.
As you design, consult the developers and/or architects on your team to ensure the various components of your design will work together. Later in the project, they will use these designs/technical specifications to build the IIoT application.
02. Review technical design
Review your technical design with project team members and stakeholders. Communicate how the design satisfies your application and user requirements. Ask for feedback about whether the design fulfills the use case and appears usable. If stakeholders have concerns or questions about the design, address them before you begin development.
Determine Implementation and Testing Approach
Determine the process you will follow to build, test, and release your ThingWorx applications.
The team developing your ThingWorx applications should begin planning their development processes (DevOps). A robust DevOps plan will improve communication, speed up your deployment, and reduce mistakes. ThingWorx development is best suited for an Agile process that allows you to create and iterate quickly. Consider how you will manage code and track work throughout the Industrial IoT project.
As you plan DevOps, also consider your source control practices: how will the various developers access and back up the code as they collaborate to build an application? Which development environments will they use? Your development team may already have a source control solution in place: if so, explore whether ThingWorx integrates with the system. If your organization does not have a source control system, PTC can recommend one.
PTC offers a DevOps workshop that covers source control, process, and coding/development best practices specific to ThingWorx. This workshop ensures your ThingWorx configurations are being managed properly to speed your development cycles.
02. Determine your testing approach
Decide how you’ll test your ThingWorx applications prior to launching. PTC recommends incorporating three levels of testing into your DevOps:
Unit testing: where you test each individual component independently to ensure they’re operating as expected
System testing: testing the features and functionality of a collection of components
User acceptance testing (UAT): bringing in select end users to ensure the application is meeting their needs
Testing should occur in a QA environment that is a close replica of your production environment. Testing plans should be unique to each application to ensure you’re testing the appropriate things. Always perform thorough testing before you push your application into live production.
Finalize Your Project Plan
Compile the work you’ve done to create your Industrial IoT strategy into one project plan.
With your IIoT initiative planning nearly complete, it’s time to compile a final list of project costs.
Tally up the final costs of:
Equipment, such as hardware, software, and networking
Internal and external resources required
Any potential financial impact this project could have on your operations due to outages, shortages, etc.
PTC recommends including a 10-15% contingency on your final budget to support unplanned costs that arise during the project.
02. Document final project plan
Your project plan should provide a detailed view of everything you need to do to complete your initial IIoT project. This plan should include specific tasks, the people responsible for these tasks, and when each task needs to be completed. Use the documented strategies you’ve created throughout your IIoT planning as your starting point. No task is too small here: include everything from development and launch tasks to training and communication plans. You should also include important project milestones you can report back on to your stakeholders.
03. Get approval on final budget and project plan
Take your detailed costs and final project plan back to your executive stakeholders for final review and approval.
Acquire Equipment and Resources
Obtain the equipment and resources required for successful implementation.
Ensure you have access to all the equipment you will need to execute your Industrial IoT project. If you don’t already have what you need, purchase it now. Necessary equipment may include hardware, networking equipment, PTC software, and any needed third-party software.
02. Obtain resources
Ensure you have the right people secured to work on your project. If you’re using internal resources, make sure they have enough hours allocated to this initiative. Get approval from employees’ managers, if necessary. If you’re using external resources, start sourcing outside providers right away and ensure they have the skills and ThingWorx experience necessary for your project.
Set Up Your Account
First, meet with your Customer Success Manager. Then, set up the account you’ll use to access software downloads and technical support.
You will need a PTC Support Account to download ThingWorx software and access technical support.
To create your account, you must supply one of the following numbers:
Your Service Contract Number (SCN)
Your Sales Order Number (SON)
Your Site Number
PTC will send a software order fulfillment email after your purchase is complete: this email contains the information above. If you can’t find this information, contact PTC technical support.
Configure the infrastructure that will support your Industrial IoT initiatives. Then, install the ThingWorx platform and any other software necessary for your use case.
Set up your infrastructure according to your documented architecture plan. This includes any servers, scanners, networking, hardware, and workstations needed to support ThingWorx across your organization. Prioritize the hardware and servers you need to get your development environment up and running so you can start developing your ThingWorx application as soon as possible.
02. Install the ThingWorx platform
Before you begin, review the “ThingWorx System Requirements” document to ensure you’re ready for installation.
To access ThingWorx software, you must log in to PTC eSupport. If you don’t already have a PTC account, create one now.
To install the ThingWorx platform, log in to the PTC eSupport Portal and select “Download Software.” For detailed steps on installing ThingWorx Platform, see the “Installing and Upgrading ThingWorx” guide in the ThingWorx help center.
03. Install and import additional software required for your use case
If your use case also requires additional ThingWorx software, log in to the PTC eSupport Portal and select “Download Software.”
Additional software includes:
ThingWorx Analytics
ThingWorx Connection Server
ThingWorx Edge Microservers
ThingWorx Edge SDK
ThingWorx industrial Connectivity
For detailed steps on installing additional software, see the applicable installation guide on the help center.
If your use case requires one or both of the ThingWorx applications, Controls Advisor and Asset Advisor, you'll need to configure the ThingWorx platform to enable extension imports. For detailed steps on importing ThingWorx Apps, see the “Importing the ThingWorx Apps Extension” guide in the ThingWorx Apps help center.
If you’re unsure what software your organization has purchased licenses for, use the “Download Software by Sales Order Number (SON)” option. You’ll need your customer number and sales order number.
Ensure your organization’s security measures will allow ThingWorx to communicate with your systems. Work with your IT or network infrastructure team to plan how data will pass from your network to ThingWorx. In some cases, the network firewall(s) will block connections, which will prevent your integrations from passing data to ThingWorx.
Configure ThingWorx Users
Provide ThingWorx access to the team building your Industrial IoT application. Then create user groups for the rest of the users in your organization.
Create the structure for grouping your users. ThingWorx will assign user permissions (what the user is allowed to see and do) according to the groupings you’re setting up. You can also set permissions at an individual user level. Create your groupings, following the structure you designed earlier in the project.
You must establish this user group framework in order to properly test the application. If necessary, provide ThingWorx credentials to necessary stakeholders or other users who will help you test the application. Make sure they have access to what they need. Later on, you will provide accounts to all the people at your organization who will use ThingWorx.
02. Add initial users
Provide ThingWorx accounts for the team members developing your IIoT application. You will add these initial users in ThingWorx Composer. ThingWorx includes a default “Administrators” group. Users in this group have complete access to everything. We recommend you assign developers to the “administrator” group, which will provide the permissions they need to develop and validate the application.
For now, focus on creating user accounts for developers and other team members building the application. You will create user accounts for the end users of the application later.
Guided by your integration and connectivity strategy, connect to any necessary edge devices. If possible, determine who programmed the device you’re connecting to and get their help. It may be a control engineer or programmer within your organization, a third-party vendor, or machine builder. This person can provide invaluable expertise as you connect to edge devices.
At this stage, you will use ThingWorx to model the data from your assets, machines, and/or systems. Your Asset Data Model will provide structure for this data. The data model specifies relationships among data points and provides the framework for your IIoT application. Follow the data model design you created during planning.
In less-common cases, your machine’s programmable logic controller (PLC) may require modifications in order to connect to ThingWorx. For example, you may need to modify a PLC in order to create serial or ethernet connections.
A control engineer or programmer within your organization should work with the machine builder to modify the PLC.
04. Map data tags
Data tag mapping involves labeling data from an asset, machine, or system and linking it to your data model in ThingWorx. You will tag data in such a way that ThingWorx can find and use it.
For example, if your IIoT application will display the speed of a conveyer belt, you must locate the variable for “speed” within the device. The conveyer belt’s PLC houses thousands of data points which are labeled with vague terms like “register 402.” You would use Kepware to connect to the machine and discover the tags. Once you locate the correct data point, you would apply “tags” to the data that help you find and leverage it in ThingWorx. In this case, you would apply a “speed” data tag.
Data tag mapping can be complex and time consuming. A programmer within your organization, a third-party vendor, or the machine manufacturer may be able help.
Execute Application Design
Guided by your technical design, build the Industrial IoT application in ThingWorx. Verify the resulting application satisfies your business and user requirements.
Based on the final technical design, the designer and/or developer will use ThingWorx Composer to build the application user interface.
It’s helpful to understand these components within ThingWorx:
Mashups are webpage visualizations that deliver information from the ThingWorx model.
Widgets are the components that make up the Mashup, such as text boxes, buttons, and navigation links.
Data services call data into the Mashup.
We recommend you connect some data at this stage. It’s not necessary to have all the data you need before you begin development. But designing with real—albeit incomplete—data will eliminate the need to manufacture dummy data. Ideally, all your data should be ready within a few weeks after development begins.
Verify the design is working properly, the data is flowing correctly, and the widgets work correctly. Iterate as needed until everything works. If you don’t have data to work with yet, use dummy data to check your work. Later, you will test the application more thoroughly.
During the planning phase of your Industrial IoT project, you outlined a process for managing code across environments (DevOps). As you develop your application, ensure all the developers follow the agreed-upon DevOps processes. As you create and test solutions, your DevOps process ensures your work is backed up. DevOps also prevents team members from accidentally overwriting or deleting pieces of the application.
03. Review application design
When your application is nearing completion, confirm whether it satisfies your use case, application requirements, and user requirements. Perform this step several weeks before the planned go-live date: give your team enough time to fix any issues that may arise. If you built your application in house, consider engaging PTC’s ThingWorx experts to review your solution and identify possible risks.
In the next phase, you will test the application to verify the data flows correctly and users can access the information they need.
We recommend you create documentation that details how the application was developed. After deployment, the team supporting end users will need this documentation to troubleshoot issues and fix bugs.
Build Your Integrations
Connect to the systems that will supply the data you need for your application. ThingWorx offers a variety of pre-built connectors, but some third-party systems require custom integration connectors.
Connect to the third-party systems, assets, and/or tools your use case requires by creating integration connectors. Follow the integration strategy you created earlier in the project. A solution architect can help determine which connectors are necessary to extract the data you need. If possible, work with an expert who understands the system you’re connecting to. Also consider how network configuration will affect your connections: some ports may be blocked or have stricter security in a production environment compared to a test/QA environment.
If necessary, build custom integrations to the systems, assets, and/or tools your use case requires. In most cases, you will use REST APIs to create these integrations. Configuration will be necessary within the system you’re connecting to. A solutions architect can help determine how to build these connectors. If possible, work with an expert who understands the system you’re connecting to.
In order to trigger ThingWorx to recognize these new connectors, you will need to restart the server several times—which will interrupt others who are working on that server. We recommend you work on a standalone server as you implement connectors.
Make sure your users have access to the right components within the application. We recommend several users log in to ThingWorx in a test/QA environment and verify they have access to everything they need. Test the user permissions for each of your designated user groups (administrator, developer, user, etc.). If someone can’t access a Mashup or if they have too much access, alter their permissions.
Unit level testing verifies each individual piece of functionality works correctly.
Functional testing ensures the application will perform the way that a user expects.
If you find issues, consider rolling the application back to your development environment for fixing.
03. Conduct user acceptance testing
Test the application in a test/QA environment with a few potential users (plant managers, frontline workers, or other available participants) to ensure what you’ve built meets their needs.
User Acceptance Testing should address questions like:
Can the test participants navigate and use the application?
Is it what they expected? Is anything confusing?
Is it missing any functionality that their system of record has today?
Did the application function correctly during the test?
You may learn important insights during this phase and choose to act on them later. If the application does not meet 100 percent of the user’s needs, decide whether to pause deployment or to launch as-is.
04. Cut over integrations
Transition your integrations to start feeding data into ThingWorx. After you turn on the integrations, verify the data is accurately flowing from the asset/tool/system as expected. Make sure you’re not receiving extraneous data. If you’re switching from an existing legacy system, compare the data from the old system and what you’re seeing in ThingWorx to be sure they’re identical. We recommend you monitor the data for several hours before you continue through deployment.
05. Migrate historical data
If you are migrating existing data from other systems, verify it imports to ThingWorx correctly. A developer, IT expert, data scientist or engineer can help. It may take several weeks to fully migrate months or years of historical data: we recommend you import data on a rolling basis. Prioritize the data you need to understand trends or make sense of the data you’re collecting going forward. If you’re retiring any existing systems, migrate that data sooner.
Keep in mind the more data you migrate and store, the more it will affect system performance.
06. Confirm system performance
Once assets are connected and data is flowing, perform a variety of load tests to check whether system load, performance, and availability is acceptable. For example, if you expect data to travel from an asset through the application in 5 seconds, verify the application is delivering that level of performance. Be sure your server is large enough to handle the data. Be realistic about your expectations: the faster your system, the higher your server costs.
It’s important to stress test the system. Test the user load and device input load. Simulate several scenarios—including less-likely situations when the system is processing more data than expected. For example, if your application is expected to process 10 megabytes per minute, simulate 100 megabytes per minute to ensure the system doesn’t crash under extreme conditions. While these scenarios may be uncommon, we recommend you prepare the system to handle them.
07. Promote to production
After you have performed all the necessary testing in the test/QA environment, you’re ready to promote the code to production. This step “publishes” your application—deploying it to your manufacturing plant. Ensure you have a backup in place before promoting to production. If you have followed a thorough DevOps process, your work should already be backed up.
To promote to production, the developer/architect will import data and entities to the production server. If an issue arises, do not make changes to the application in the production environment. First, make adjustments and test them in the development environment. Second, promote the code to the test/QA environment and test thoroughly. Third, promote the code to production.
Once the technical team has successfully deployed the application, notify project team members and stakeholders. The application is now collecting real data, communicating with your assets, and is available for use.
08. Perform final smoke test
The final smoke test will help you determine whether the application is ready to deploy. If any issues arose during unit, functional and/or user acceptance testing; re-test to ensure they’re fixed. Run through several test scenarios, like adding a new user or interacting with a Mashup. Double check your integrations for data leakage.
Prepare Your Team for Deployment
Ensure the workers who will support and use your Industrial IoT applications are ready for go-live.
Document how your Industrial IoT application(s) are designed and implemented. This documentation is crucial for supporting and using the applications. We have recommended you document the solution as you build it. Now you will compile the various documentation pieces your team has created throughout the project.
Application documentation should include:
Organization structure: Which people are assigned to which user group, within ThingWorx?
User and group permissions: Document the permissions granted to each user within ThingWorx. Specify visibility groups and runtime groups. For example, document whether your application grants developer users permission to view service X, but not service Y. This will help your support team quickly resolve issues that may arise after deployment.
Application details: How do services, data, and mashups interact? Document where your data flows into which services and mashups.
Basic end user information: Provide instructions to the workers who will be using your IIoT applications.
Document how to use the application and how to get support in case of issues. This is the only documentation your end users should need.
Application documentation should be consistently updated. When you make a change to the application, update the documentation to reflect that change.
02. Add admins, support, and end users to user groups
If you have not done so already, add your administrators, application support team, and end users to ThingWorx. Follow the plan you created to assign each user to the appropriate user groups. Ensure these users have permission to access everything they need within the application.
03. Train admins and support
Train the teams who will administer and provide technical support to end users, post-deployment. Ensure they’re familiar with the application documentation and understand how the solution is built.
Your support organization must learn how your organization structure and user permissions are set up. One of the most common issues that ThingWorx users encounter is caused by user permissions. For example, if a user does not have permission to view a specific page, they will get an error message when they try to access it. With the right documentation and training, your support team can quickly resolve this issue.
04. Train end users and gather acceptance
Train the workers who will be using your IIoT applications. The depth and format of your training will vary, depending on its complexity.
Ensure your end users know:
How to use the application.
How the application will affect their job or role.
How to navigate the application on different devices (desktop computers, tablets, etc.), if applicable.
How to get help from the support team.
Where to access documentation.
How to troubleshoot and report errors.
Inform end users when the application will go live. A few weeks after deployment, follow up with them to get feedback.
Support Application through Hypercare
In the weeks after you deploy your Industrial IoT application, you will provide intensive hands-on support. Prevent downtime by anticipating and quickly resolving issues.
After deployment, the team who built your IIoT applications will transfer ownership of the live solution to your designated support organization. This team will be responsible for providing technical support to ThingWorx users, among other duties. Ensure the application support team is trained and prepared to resolve potential issues.
After handoff, your support organization should never make changes to the application in production. If there is a problem, make the necessary changes on the development server, test them, and then publish them to production. Finally, note the change in the documentation.
02. Provide Hypercare support
During and immediately following deployment, your application support team must be readily available to resolve issues. They should also know how to reach IT, if necessary. Ideally, the architect(s) and/or developer(s) who built the solution will be available to help if needed.
If your application is running 24 hours per day, 7 days per week, then 1-2 employees should be reachable outside of normal business hours in case of emergencies. If you thoroughly tested the system before deployment, emergencies are less likely.
This Hypercare period typically lasts 7-14 days. Hypercare ends when the application is functioning as expected. There may be ongoing bugs or minor fixes that developers address later.
Measure Business Impact
Revisit the goals and metrics you established for your Industrial IoT project. Then, gather the data you need to measure success.
Revisit the goals your organization set in your measurement strategy. Review which metrics you measured to establish a baseline. Then, gather the metrics for your current state (now that your IIoT application is functioning as expected). If you don’t have access to the data you need, reach out to the plant manager or leader. Finally, compare the post-deployment metrics to the pre-deployment baseline.
We recommend you wait 30-90 days—depending on your use case—to gather post-deployment metrics. While it’s likely your organization will see improvements almost immediately, some metrics require several weeks of data to properly measure. Especially if workers are slow to adopt the solution. Account for unplanned benefits that IIoT has provided to your organization: there may be less-tangible value to your operations that’s worth highlighting.
Share the results with the project sponsor, organizational leaders, plant managers, and other stakeholders.
Do not duplicate or distribute this downloaded file without written permission from PTC.
Overview: Build Your ThingWorx Solution for Manufacturing
Use this guide as you plan, design, develop, and deploy a ThingWorx solution for manufacturing. Follow step-by-step instructions and get resources to help you get the most out of the product. For example, the guide will help you establish business goals and develop long-term ThingWorx strategy.
The information is useful for:
Project Managers
Project Stakeholders
System Administrators
Technical Staff
Developers
UI/UX Designers
Get started
What is a Success Path?
A Success Path is an online guide to help you implement a specific PTC product at your organization. Each path provides step-by-step instructions and includes training and resources along the way. Use a Success Path to help your organization get the most out of a product and achieve your business goals.
Product Documentation
Find detailed technical documentation on Creo+ in our Help Center
Ask the Community
Visit PTC's Creo Community to get support Peer-to-Peer, from our product management and assistance teams. Share ideas, give feedback and browse the wealth of information on using Creo+
Technical Support
Need help from our support team? Log a case with eSupport using our Case Logger or find an answer using our new Creo Admin Troubleshooter tool.
Contact Us
Have a question? Submit your contact information and we’ll reach out within 1 business day. You’re never obligated to purchase or commit.
Support Portal
Contact an Expert
Training and Skills
Join the PTC Community
